kreuzberg 3.3.0__py3-none-any.whl → 3.8.1__py3-none-any.whl

kreuzberg/__init__.py

@@ -1,11 +1,15 @@
+from importlib.metadata import version
+
+from kreuzberg._entity_extraction import SpacyEntityExtractionConfig
 from kreuzberg._gmft import GMFTConfig
+from kreuzberg._language_detection import LanguageDetectionConfig
 from kreuzberg._ocr._easyocr import EasyOCRConfig
 from kreuzberg._ocr._paddleocr import PaddleOCRConfig
 from kreuzberg._ocr._tesseract import TesseractConfig
 
 from ._ocr._tesseract import PSMMode
 from ._registry import ExtractorRegistry
-from ._types import ExtractionConfig, ExtractionResult, Metadata, TableData
+from ._types import Entity, ExtractionConfig, ExtractionResult, Metadata, TableData
 from .exceptions import KreuzbergError, MissingDependencyError, OCRError, ParsingError, ValidationError
 from .extraction import (
     batch_extract_bytes,
@@ -18,21 +22,24 @@ from .extraction import (
     extract_file_sync,
 )
 
-__version__ = "3.2.0"
+__version__ = version("kreuzberg")
 
 __all__ = [
     "EasyOCRConfig",
+    "Entity",
     "ExtractionConfig",
     "ExtractionResult",
     "ExtractorRegistry",
     "GMFTConfig",
     "KreuzbergError",
+    "LanguageDetectionConfig",
     "Metadata",
     "MissingDependencyError",
     "OCRError",
     "PSMMode",
     "PaddleOCRConfig",
     "ParsingError",
+    "SpacyEntityExtractionConfig",
     "TableData",
     "TesseractConfig",
     "ValidationError",

kreuzberg/_api/main.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from json import dumps
+from typing import TYPE_CHECKING, Annotated, Any
+
+from kreuzberg import (
+    ExtractionResult,
+    KreuzbergError,
+    MissingDependencyError,
+    ParsingError,
+    ValidationError,
+    batch_extract_bytes,
+)
+
+if TYPE_CHECKING:
+    from litestar.datastructures import UploadFile
+
+try:
+    from litestar import Litestar, Request, Response, get, post
+    from litestar.contrib.opentelemetry import OpenTelemetryConfig, OpenTelemetryPlugin
+    from litestar.enums import RequestEncodingType
+    from litestar.logging import StructLoggingConfig
+    from litestar.params import Body
+    from litestar.status_codes import (
+        HTTP_400_BAD_REQUEST,
+        HTTP_422_UNPROCESSABLE_ENTITY,
+        HTTP_500_INTERNAL_SERVER_ERROR,
+    )
+except ImportError as e:
+    raise MissingDependencyError.create_for_package(
+        dependency_group="litestar",
+        functionality="Litestar API and docker container",
+        package_name="litestar",
+    ) from e
+
+
+def exception_handler(request: Request[Any, Any, Any], exception: KreuzbergError) -> Response[Any]:
+    if isinstance(exception, ValidationError):
+        status_code = HTTP_400_BAD_REQUEST
+    elif isinstance(exception, ParsingError):
+        status_code = HTTP_422_UNPROCESSABLE_ENTITY
+    else:
+        status_code = HTTP_500_INTERNAL_SERVER_ERROR
+
+    message = str(exception)
+    details = dumps(exception.context)
+
+    if request.app.logger:
+        request.app.logger.error(
+            "API error",
+            method=request.method,
+            url=str(request.url),
+            status_code=status_code,
+            message=message,
+            context=exception.context,
+        )
+
+    return Response(
+        content={"message": message, "details": details},
+        status_code=status_code,
+    )
+
+
+@post("/extract", operation_id="ExtractFiles")
+async def handle_files_upload(
+    data: Annotated[list[UploadFile], Body(media_type=RequestEncodingType.MULTI_PART)],
+) -> list[ExtractionResult]:
+    """Extracts text content from an uploaded file."""
+    return await batch_extract_bytes(
+        [(await file.read(), file.content_type) for file in data],
+    )
+
+
+@get("/health", operation_id="HealthCheck")
+async def health_check() -> dict[str, str]:
+    """A simple health check endpoint."""
+    return {"status": "ok"}
+
+
+app = Litestar(
+    route_handlers=[handle_files_upload, health_check],
+    plugins=[OpenTelemetryPlugin(OpenTelemetryConfig())],
+    logging_config=StructLoggingConfig(),
+    exception_handlers={
+        KreuzbergError: exception_handler,
+    },
+)

kreuzberg/_entity_extraction.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import TYPE_CHECKING, Any
+
+from kreuzberg._types import Entity
+from kreuzberg.exceptions import MissingDependencyError
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from pathlib import Path
+
+
+@dataclass(unsafe_hash=True, frozen=True)
+class SpacyEntityExtractionConfig:
+    """Configuration for spaCy-based entity extraction."""
+
+    model_cache_dir: str | Path | None = None
+    """Directory to cache spaCy models. If None, uses spaCy's default."""
+
+    language_models: dict[str, str] | tuple[tuple[str, str], ...] | None = None
+    """Mapping of language codes to spaCy model names.
+
+    If None, uses default mappings:
+    - en: en_core_web_sm
+    - de: de_core_news_sm
+    - fr: fr_core_news_sm
+    - es: es_core_news_sm
+    - pt: pt_core_news_sm
+    - it: it_core_news_sm
+    - nl: nl_core_news_sm
+    - zh: zh_core_web_sm
+    - ja: ja_core_news_sm
+    """
+
+    fallback_to_multilingual: bool = True
+    """If True and language-specific model fails, try xx_ent_wiki_sm (multilingual)."""
+
+    max_doc_length: int = 1000000
+    """Maximum document length for spaCy processing."""
+
+    batch_size: int = 1000
+    """Batch size for processing multiple texts."""
+
+    def __post_init__(self) -> None:
+        if self.language_models is None:
+            object.__setattr__(self, "language_models", self._get_default_language_models())
+
+        if isinstance(self.language_models, dict):
+            object.__setattr__(self, "language_models", tuple(sorted(self.language_models.items())))
+
+    @staticmethod
+    def _get_default_language_models() -> dict[str, str]:
+        """Get default language model mappings based on available spaCy models."""
+        return {
+            "en": "en_core_web_sm",
+            "de": "de_core_news_sm",
+            "fr": "fr_core_news_sm",
+            "es": "es_core_news_sm",
+            "pt": "pt_core_news_sm",
+            "it": "it_core_news_sm",
+            "nl": "nl_core_news_sm",
+            "zh": "zh_core_web_sm",
+            "ja": "ja_core_news_sm",
+            "ko": "ko_core_news_sm",
+            "ru": "ru_core_news_sm",
+            "pl": "pl_core_news_sm",
+            "ro": "ro_core_news_sm",
+            "el": "el_core_news_sm",
+            "da": "da_core_news_sm",
+            "fi": "fi_core_news_sm",
+            "nb": "nb_core_news_sm",
+            "sv": "sv_core_news_sm",
+            "ca": "ca_core_news_sm",
+            "hr": "hr_core_news_sm",
+            "lt": "lt_core_news_sm",
+            "mk": "mk_core_news_sm",
+            "sl": "sl_core_news_sm",
+            "uk": "uk_core_news_sm",
+        }
+
+    def get_model_for_language(self, language_code: str) -> str | None:
+        """Get the appropriate spaCy model for a language code."""
+        if not self.language_models:
+            return None
+
+        models_dict = dict(self.language_models) if isinstance(self.language_models, tuple) else self.language_models
+
+        if language_code in models_dict:
+            return models_dict[language_code]
+
+        base_lang = language_code.split("-")[0].lower()
+        if base_lang in models_dict:
+            return models_dict[base_lang]
+
+        return None
+
+    def get_fallback_model(self) -> str | None:
+        """Get fallback multilingual model if enabled."""
+        return "xx_ent_wiki_sm" if self.fallback_to_multilingual else None
+
+
+def extract_entities(
+    text: str,
+    entity_types: Sequence[str] = ("PERSON", "ORGANIZATION", "LOCATION", "DATE", "EMAIL", "PHONE"),
+    custom_patterns: frozenset[tuple[str, str]] | None = None,
+    languages: list[str] | None = None,
+    spacy_config: SpacyEntityExtractionConfig | None = None,
+) -> list[Entity]:
+    """Extract entities from text using custom regex patterns and/or a NER model.
+
+    Args:
+        text: The input text to extract entities from.
+        entity_types: List of entity types to extract using the NER model.
+        custom_patterns: Tuple mapping entity types to regex patterns for custom extraction.
+        languages: List of detected languages to choose appropriate spaCy models.
+        spacy_config: Configuration for spaCy entity extraction.
+
+    Returns:
+        list[Entity]: A list of extracted Entity objects with type, text, start, and end positions.
+
+    Raises:
+        MissingDependencyError: If `spacy` is not installed.
+    """
+    entities: list[Entity] = []
+    if custom_patterns:
+        custom_patterns_dict = dict(custom_patterns)
+        for ent_type, pattern in custom_patterns_dict.items():
+            entities.extend(
+                Entity(type=ent_type, text=match.group(), start=match.start(), end=match.end())
+                for match in re.finditer(pattern, text)
+            )
+
+    if spacy_config is None:
+        spacy_config = SpacyEntityExtractionConfig()
+
+    try:
+        import spacy  # noqa: F401
+    except ImportError as e:
+        raise MissingDependencyError.create_for_package(
+            package_name="spacy",
+            dependency_group="entity-extraction",
+            functionality="Entity Extraction",
+        ) from e
+
+    model_name = _select_spacy_model(languages, spacy_config)
+    if not model_name:
+        return entities
+
+    nlp = _load_spacy_model(model_name, spacy_config)
+    if not nlp:
+        return entities
+
+    if len(text) > spacy_config.max_doc_length:
+        text = text[: spacy_config.max_doc_length]
+
+    doc = nlp(text)
+
+    entity_type_mapping = {etype.upper() for etype in entity_types}
+
+    entities.extend(
+        Entity(
+            type=ent.label_,
+            text=ent.text,
+            start=ent.start_char,
+            end=ent.end_char,
+        )
+        for ent in doc.ents
+        if ent.label_ in entity_type_mapping or ent.label_.upper() in entity_type_mapping
+    )
+
+    return entities
+
+
+@lru_cache(maxsize=32)
+def _load_spacy_model(model_name: str, spacy_config: SpacyEntityExtractionConfig) -> Any:
+    """Load a spaCy model with caching."""
+    try:
+        import spacy
+
+        if spacy_config.model_cache_dir:
+            os.environ["SPACY_DATA"] = str(spacy_config.model_cache_dir)
+
+        nlp = spacy.load(model_name)
+
+        nlp.max_length = spacy_config.max_doc_length
+
+        return nlp
+    except (OSError, ImportError):
+        return None
+
+
+def _select_spacy_model(languages: list[str] | None, spacy_config: SpacyEntityExtractionConfig) -> str | None:
+    """Select the best spaCy model based on detected languages."""
+    if not languages:
+        return spacy_config.get_model_for_language("en")
+
+    for lang in languages:
+        model_name = spacy_config.get_model_for_language(lang)
+        if model_name:
+            return model_name
+
+    return spacy_config.get_fallback_model()
+
+
+def extract_keywords(
+    text: str,
+    keyword_count: int = 10,
+) -> list[tuple[str, float]]:
+    """Extract keywords from text using the KeyBERT model.
+
+    Args:
+        text: The input text to extract keywords from.
+        keyword_count: Number of top keywords to return. Defaults to 10.
+
+    Returns:
+        list[tuple[str, float]]: A list of tuples containing keywords and their relevance scores.
+
+    Raises:
+        MissingDependencyError: If `keybert` is not installed.
+    """
+    try:
+        from keybert import KeyBERT
+
+        kw_model = KeyBERT()
+        keywords = kw_model.extract_keywords(text, top_n=keyword_count)
+        return [(kw, float(score)) for kw, score in keywords]
+    except (RuntimeError, OSError, ValueError):
+        return []
+    except ImportError as e:
+        raise MissingDependencyError.create_for_package(
+            package_name="keybert",
+            dependency_group="entity-extraction",
+            functionality="Keyword Extraction",
+        ) from e

kreuzberg/_extractors/_base.py

@@ -3,10 +3,12 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, ClassVar
 
+from kreuzberg._types import ExtractionResult, normalize_metadata
+from kreuzberg._utils._quality import calculate_quality_score, clean_extracted_text
+
 if TYPE_CHECKING:
     from pathlib import Path
 
-    from kreuzberg import ExtractionResult
     from kreuzberg._types import ExtractionConfig
 
 
@@ -90,3 +92,39 @@ class Extractor(ABC):
         return mime_type in cls.SUPPORTED_MIME_TYPES or any(
             mime_type.startswith(supported_type) for supported_type in cls.SUPPORTED_MIME_TYPES
         )
+
+    def _apply_quality_processing(self, result: ExtractionResult) -> ExtractionResult:
+        """Apply quality post-processing to extraction result if enabled.
+
+        Args:
+            result: The raw extraction result
+
+        Returns:
+            Enhanced extraction result with quality improvements (if enabled)
+        """
+        # Only apply quality processing if enabled in config
+        if not self.config.enable_quality_processing:
+            return result
+
+        if not result.content:
+            return result
+
+        # Clean the content
+        cleaned_content = clean_extracted_text(result.content)
+
+        # Calculate quality score
+        quality_score = calculate_quality_score(cleaned_content, dict(result.metadata) if result.metadata else None)
+
+        # Add quality metadata
+        enhanced_metadata = dict(result.metadata) if result.metadata else {}
+        enhanced_metadata["quality_score"] = quality_score
+
+        # Return enhanced result
+        return ExtractionResult(
+            content=cleaned_content,
+            mime_type=result.mime_type,
+            metadata=normalize_metadata(enhanced_metadata),
+            chunks=result.chunks,
+            detected_languages=result.detected_languages,
+            tables=result.tables,
+        )

kreuzberg/_extractors/_email.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import re
+from html import unescape
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from anyio import Path as AsyncPath
+
+from kreuzberg._extractors._base import Extractor
+from kreuzberg._mime_types import EML_MIME_TYPE, PLAIN_TEXT_MIME_TYPE
+from kreuzberg._types import ExtractionResult, normalize_metadata
+from kreuzberg._utils._string import normalize_spaces
+from kreuzberg._utils._sync import run_sync
+from kreuzberg.exceptions import MissingDependencyError
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+# Import optional dependencies at module level with proper error handling
+try:
+    import mailparse
+except ImportError:
+    mailparse = None
+
+try:
+    import html2text  # type: ignore[import-not-found]
+except ImportError:
+    html2text = None
+
+# Compile regex pattern once at module level
+_HTML_TAG_PATTERN = re.compile(r"<[^>]+>")
+
+
+class EmailExtractor(Extractor):
+    SUPPORTED_MIME_TYPES: ClassVar[set[str]] = {EML_MIME_TYPE}
+
+    async def extract_bytes_async(self, content: bytes) -> ExtractionResult:
+        return await run_sync(self.extract_bytes_sync, content)
+
+    async def extract_path_async(self, path: Path) -> ExtractionResult:
+        content = await AsyncPath(path).read_bytes()
+        return await self.extract_bytes_async(content)
+
+    def _extract_email_headers(
+        self, parsed_email: dict[str, Any], text_parts: list[str], metadata: dict[str, Any]
+    ) -> None:
+        """Extract and process email headers."""
+        # Use single dict access where possible to avoid repeated lookups
+        subject = parsed_email.get("subject")
+        if subject:
+            metadata["subject"] = subject
+            text_parts.append(f"Subject: {subject}")
+
+        from_info = parsed_email.get("from")
+        if from_info:
+            from_email = from_info.get("email", "") if isinstance(from_info, dict) else str(from_info)
+            metadata["email_from"] = from_email
+            text_parts.append(f"From: {from_email}")
+
+        to_info = parsed_email.get("to")
+        if to_info:
+            if isinstance(to_info, list) and to_info:
+                to_email = to_info[0].get("email", "") if isinstance(to_info[0], dict) else str(to_info[0])
+            elif isinstance(to_info, dict):
+                to_email = to_info.get("email", "")
+            else:
+                to_email = str(to_info)
+            metadata["email_to"] = to_email
+            text_parts.append(f"To: {to_email}")
+
+        date = parsed_email.get("date")
+        if date:
+            metadata["date"] = date
+            text_parts.append(f"Date: {date}")
+
+        cc = parsed_email.get("cc")
+        if cc:
+            metadata["email_cc"] = cc
+            text_parts.append(f"CC: {cc}")
+
+        bcc = parsed_email.get("bcc")
+        if bcc:
+            metadata["email_bcc"] = bcc
+            text_parts.append(f"BCC: {bcc}")
+
+    def _extract_email_body(self, parsed_email: dict[str, Any], text_parts: list[str]) -> None:
+        """Extract and process email body content."""
+        text_content = parsed_email.get("text")
+        if text_content:
+            text_parts.append(f"\n{text_content}")
+            return  # If we have text, prefer it over HTML
+
+        html_content = parsed_email.get("html")
+        if html_content:
+            if html2text is not None:
+                # Use html2text if available (faster path)
+                h = html2text.HTML2Text()
+                h.ignore_links = True
+                h.ignore_images = True
+                converted_text = h.handle(html_content)
+                text_parts.append(f"\n{converted_text}")
+            else:
+                # Fallback: strip HTML tags and unescape entities
+                clean_html = _HTML_TAG_PATTERN.sub("", html_content)
+                clean_html = unescape(clean_html)
+                text_parts.append(f"\n{clean_html}")
+
+    def _extract_email_attachments(
+        self, parsed_email: dict[str, Any], text_parts: list[str], metadata: dict[str, Any]
+    ) -> None:
+        """Extract and process email attachments info."""
+        if parsed_email.get("attachments"):
+            attachment_names = [att.get("name", "unknown") for att in parsed_email["attachments"]]
+            metadata["attachments"] = attachment_names
+            if attachment_names:
+                text_parts.append(f"\nAttachments: {', '.join(attachment_names)}")
+
+    def extract_bytes_sync(self, content: bytes) -> ExtractionResult:
+        if mailparse is None:
+            msg = "mailparse is required for email extraction. Install with: pip install 'kreuzberg[additional-extensions]'"
+            raise MissingDependencyError(msg)
+
+        try:
+            parsed_email = mailparse.EmailDecode.load(content)
+            text_parts: list[str] = []
+            metadata: dict[str, Any] = {}
+
+            # Extract headers, body, and attachments
+            self._extract_email_headers(parsed_email, text_parts, metadata)
+            self._extract_email_body(parsed_email, text_parts)
+            self._extract_email_attachments(parsed_email, text_parts, metadata)
+
+            # Join efficiently
+            combined_text = "\n".join(text_parts)
+
+            return ExtractionResult(
+                content=normalize_spaces(combined_text),
+                mime_type=PLAIN_TEXT_MIME_TYPE,
+                metadata=normalize_metadata(metadata),
+                chunks=[],
+            )
+
+        except Exception as e:
+            msg = f"Failed to parse email content: {e}"
+            raise RuntimeError(msg) from e
+
+    def extract_path_sync(self, path: Path) -> ExtractionResult:
+        content = path.read_bytes()
+        return self.extract_bytes_sync(content)

kreuzberg/_extractors/_html.py

@@ -8,7 +8,7 @@ from anyio import Path as AsyncPath
 from kreuzberg._extractors._base import Extractor
 from kreuzberg._mime_types import HTML_MIME_TYPE, MARKDOWN_MIME_TYPE
 from kreuzberg._types import ExtractionResult
-from kreuzberg._utils._string import normalize_spaces, safe_decode
+from kreuzberg._utils._string import safe_decode
 from kreuzberg._utils._sync import run_sync
 
 if TYPE_CHECKING:
@@ -26,8 +26,20 @@ class HTMLExtractor(Extractor):
         return await run_sync(self.extract_bytes_sync, content)
 
     def extract_bytes_sync(self, content: bytes) -> ExtractionResult:
-        result = html_to_markdown.convert_to_markdown(safe_decode(content))
-        return ExtractionResult(content=normalize_spaces(result), mime_type=MARKDOWN_MIME_TYPE, metadata={}, chunks=[])
+        # Use html-to-markdown with script/nav removal for better quality
+        result = html_to_markdown.convert_to_markdown(
+            safe_decode(content),
+            preprocess_html=True,
+            preprocessing_preset="aggressive",
+            remove_navigation=True,
+            remove_forms=True,
+        )
+
+        # Skip normalize_spaces since quality processing will handle whitespace
+        extraction_result = ExtractionResult(content=result, mime_type=MARKDOWN_MIME_TYPE, metadata={}, chunks=[])
+
+        # Apply quality processing which includes normalization
+        return self._apply_quality_processing(extraction_result)
 
     def extract_path_sync(self, path: Path) -> ExtractionResult:
         content = path.read_bytes()

kreuzberg/_extractors/_image.py

@@ -1,5 +1,9 @@
 from __future__ import annotations
 
+import contextlib
+import os
+import tempfile
+from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar
 
 from anyio import Path as AsyncPath
@@ -7,6 +11,9 @@ from anyio import Path as AsyncPath
 from kreuzberg._extractors._base import Extractor
 from kreuzberg._mime_types import IMAGE_MIME_TYPES
 from kreuzberg._ocr import get_ocr_backend
+from kreuzberg._ocr._easyocr import EasyOCRConfig
+from kreuzberg._ocr._paddleocr import PaddleOCRConfig
+from kreuzberg._ocr._tesseract import TesseractConfig
 from kreuzberg._utils._tmp import create_temp_file
 from kreuzberg.exceptions import ValidationError
 
@@ -15,9 +22,6 @@ if TYPE_CHECKING:  # pragma: no cover
 
     from kreuzberg._types import ExtractionResult
 
-import contextlib
-from pathlib import Path
-
 
 class ImageExtractor(Extractor):
     SUPPORTED_MIME_TYPES: ClassVar[set[str]] = IMAGE_MIME_TYPES
@@ -56,13 +60,11 @@ class ImageExtractor(Extractor):
         if self.config.ocr_backend is None:
             raise ValidationError("ocr_backend is None, cannot perform OCR")
 
-        return await get_ocr_backend(self.config.ocr_backend).process_file(path, **self.config.get_config_dict())
+        result = await get_ocr_backend(self.config.ocr_backend).process_file(path, **self.config.get_config_dict())
+        return self._apply_quality_processing(result)
 
     def extract_bytes_sync(self, content: bytes) -> ExtractionResult:
         """Pure sync implementation of extract_bytes."""
-        import os
-        import tempfile
-
         extension = self._get_extension_from_mime_type(self.mime_type)
         fd, temp_path = tempfile.mkstemp(suffix=f".{extension}")
 
@@ -80,23 +82,26 @@ class ImageExtractor(Extractor):
         if self.config.ocr_backend is None:
             raise ValidationError("ocr_backend is None, cannot perform OCR")
 
-        from kreuzberg._ocr._tesseract import TesseractConfig
-        from kreuzberg._types import ExtractionResult
+        backend = get_ocr_backend(self.config.ocr_backend)
 
         if self.config.ocr_backend == "tesseract":
-            from kreuzberg._multiprocessing.sync_tesseract import process_batch_images_sync_pure
-
-            if isinstance(self.config.ocr_config, TesseractConfig):
-                config = self.config.ocr_config
-            else:
-                config = TesseractConfig()
-
-            results = process_batch_images_sync_pure([str(path)], config)
-            if results:
-                return results[0]
-            return ExtractionResult(content="", mime_type="text/plain", metadata={}, chunks=[])
-
-        raise NotImplementedError(f"Sync OCR not implemented for {self.config.ocr_backend}")
+            config = (
+                self.config.ocr_config if isinstance(self.config.ocr_config, TesseractConfig) else TesseractConfig()
+            )
+            result = backend.process_file_sync(path, **config.__dict__)
+        elif self.config.ocr_backend == "paddleocr":
+            paddle_config = (
+                self.config.ocr_config if isinstance(self.config.ocr_config, PaddleOCRConfig) else PaddleOCRConfig()
+            )
+            result = backend.process_file_sync(path, **paddle_config.__dict__)
+        elif self.config.ocr_backend == "easyocr":
+            easy_config = (
+                self.config.ocr_config if isinstance(self.config.ocr_config, EasyOCRConfig) else EasyOCRConfig()
+            )
+            result = backend.process_file_sync(path, **easy_config.__dict__)
+        else:
+            raise NotImplementedError(f"Sync OCR not implemented for {self.config.ocr_backend}")
+        return self._apply_quality_processing(result)
 
     def _get_extension_from_mime_type(self, mime_type: str) -> str:
         if mime_type in self.IMAGE_MIME_TYPE_EXT_MAP: